package com.offcn.order.service.impl;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.offcn.entity.Cart;
import com.offcn.entity.PageResult;
import com.offcn.order.dao.OrderItemMapper;
import com.offcn.order.dao.OrderMapper;
import com.offcn.order.dao.PayLogMapper;
import com.offcn.order.service.OrderService;
import com.offcn.pojo.Order;
import com.offcn.pojo.OrderItem;
import com.offcn.pojo.PayLog;
import com.offcn.sellergood.feign.ItemFeign;
import com.offcn.utils.IdWorker;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;


@Service
public class OrderServiceImpl extends ServiceImpl<OrderMapper,Order> implements OrderService {
    @Autowired
    private StringRedisTemplate redisTemplate; // 注入redis样板对象

    @Autowired
    private OrderItemMapper orderItemMapper;

    @Autowired
    private OrderMapper orderMapper;

    @Autowired
    private ItemFeign itemFeign;

    @Autowired
    private PayLogMapper payLogMapper;
    /**
     * @param: Order(paymentType,receiverAreaName,receiverMobile,receiverZipCode,receiver):从前端传来的数据
     * @return: 
     * @description: 
     * @analyze: 
     */
    @Override
    public void add(Order order) {
        // 1.先从redis中获取购物车的数据：根据用户名来获取，用户名的获取在controller完成
        String carts = String.valueOf(redisTemplate.boundHashOps("cartList").get(order.getUserId()));
        List<Cart> cartList = JSON.parseArray(carts, Cart.class);

        // =================订单日志的操作=========================
        List<String> orderIdlist = new ArrayList<>(); // 每生产一次订单，就需要添加到payLog表一个记录
        BigDecimal totalMoney = new BigDecimal("0"); // 定义支付总计金额为0
        // =====================================================

        // 由于每个用户有可能有多个购物车列表
        for (Cart cart : cartList) {
            // 2.创建订单
            // 前端：Order(String paymentType,String receiverAreaName,String receiverMobile,String receiverZipCode,String receiver)
            // 后端：Order(Long orderId,String payment,String status,Date createTime,Date updateTime,String sellerId,String userId)
            Order tbOrder = new Order();
            // 2.1 前端数据的操作
            tbOrder.setPaymentType(order.getPaymentType());// 支付类型
            tbOrder.setReceiverAreaName(order.getReceiverAreaName());// 收货人地址
            tbOrder.setReceiverMobile(order.getReceiverMobile());// 收货人手机
            tbOrder.setReceiverZipCode(order.getReceiverZipCode());// 收货人邮编
            tbOrder.setReceiver(order.getReceiver());// 收货人
            // 2.2 后端数据的操作
            IdWorker idWorker = new IdWorker(1,1);// 使用雪花算法来创建orderId
            long orderId = idWorker.nextId();
            tbOrder.setOrderId(orderId);// 订单id

            BigDecimal payment = new BigDecimal("0"); // 设置实付金额初始值为0，通过遍历购物车中的品订单列表，获取每个商品的总计
            for (OrderItem orderItem : cart.getOrderItemList()) {
                orderItem.setId(idWorker.nextId());// 为每一个订单详情实体类设置id，依旧使用雪花算法
                orderItem.setOrderId(orderId);// 将订单id加入实体类中
                orderItemMapper.insert(orderItem); // 将修改后的订单详情实体类添加
                payment = payment.add(orderItem.getTotalFee()); // 将大数据类型对象通过doubleValue()转为基本类型
            }
            tbOrder.setPayment(String.valueOf(payment.doubleValue())); // 实付金额:将基本类型转为字符串：int+""、String.valueOf(int)...

            tbOrder.setStatus("1"); // 状态：未支付
            tbOrder.setCreateTime(new Date());// 订单创建时间
            tbOrder.setUpdateTime(new Date());// 订单更新时间
            tbOrder.setSellerId(cart.getSellerId());// 商家ID
            tbOrder.setUserId(order.getUserId());// 用户id:该操作是在controller中获取的

            // =====================================================
            totalMoney = totalMoney.add(payment);
            orderIdlist.add(String.valueOf(orderId));
            // =====================================================

            this.save(tbOrder); // 将toOrder实体类添加到表中
        }
        // =====================================================
        if (order.getPaymentType().equals("1")) { // 在线支付，需要生产支付日志记录
            PayLog payLog = new PayLog();
            IdWorker idWorker = new IdWorker(1, 2);
            long outTradeNo = idWorker.nextId(); // 支付订单号
            payLog.setOutTradeNo(String.valueOf(outTradeNo));
            payLog.setCreateTime(new Date()); // 创建日期
            payLog.setTotalFee(totalMoney.longValue()); // 支付金额（分）
            System.out.println("支付的金额:" + payLog.getTotalFee());
            payLog.setUserId(order.getUserId());//用户ID
            payLog.setTradeState("0");// 支付状态为未支付
            payLog.setOrderList(String.valueOf(orderIdlist).replace("[","").replace("]",""));

            payLogMapper.insert(payLog); // 最终插入记录
            // 将支付日志存入redis中
            String payLog_json = JSON.toJSONString(payLog);
            redisTemplate.boundHashOps("payLog").put(order.getUserId(),payLog_json); // 根据用户名来存入
        }
        // =====================================================

        // 减库存
        itemFeign.decr();
        // redisTemplate.boundHashOps("cartList").delete(order.getUserId()); // 最后将购物车数据清除
    }
    @Override
    public PayLog searchPayLogFromRedis(String username) {
        String payLog_json = (String) redisTemplate.boundHashOps("payLog").get(username);
        PayLog payLog = JSON.parseObject(payLog_json, PayLog.class);
        return payLog;
    }

    @Override
    public void updateStatus(String out_trand_on, String trand_no) {
        PayLog payLog = payLogMapper.selectById(out_trand_on);
        payLog.setPayTime(new Date());
        payLog.setTransactionId(trand_no);
        payLog.setTradeState("1"); // 已经支付
        payLogMapper.updateById(payLog);
        // 修改订单的支付状态
        String orderList = payLog.getOrderList();
        String[] orderIds = orderList.split(",");
        for (String orderId : orderIds) {
            Order order = orderMapper.selectById(orderId);
            if (order != null) {
                order.setStatus("2"); // 已经支付
                orderMapper.updateById(order);
            }
        }
        // 清除payLog对应的redis
        redisTemplate.boundHashOps("payLog").delete(payLog.getUserId());
    }

    /**
     * Order条件+分页查询
     * @param order 查询条件
     * @param page 页码
     * @param size 页大小
     * @return 分页结果
     */
    @Override
    public PageResult<Order> findPage(Order order, int page, int size){
         Page<Order> mypage = new Page<>(page, size);
        QueryWrapper<Order> queryWrapper = this.createQueryWrapper(order);
        IPage<Order> iPage = this.page(mypage, queryWrapper);
        return new PageResult<Order>(iPage.getTotal(),iPage.getRecords());
    }

    /**
     * Order分页查询
     * @param page
     * @param size
     * @return
     */
    @Override
    public PageResult<Order> findPage(int page, int size){
        Page<Order> mypage = new Page<>(page, size);
        IPage<Order> iPage = this.page(mypage, new QueryWrapper<Order>());

        return new PageResult<Order>(iPage.getTotal(),iPage.getRecords());
    }

    /**
     * Order条件查询
     * @param order
     * @return
     */
    @Override
    public List<Order> findList(Order order){
        //构建查询条件
        QueryWrapper<Order> queryWrapper = this.createQueryWrapper(order);
        //根据构建的条件查询数据
        return this.list(queryWrapper);
    }


    /**
     * Order构建查询对象
     * @param order
     * @return
     */
    public QueryWrapper<Order> createQueryWrapper(Order order){
        QueryWrapper<Order> queryWrapper = new QueryWrapper<>();
        if(order!=null){
            // 订单id
            if(!StringUtils.isEmpty(order.getOrderId())){
                 queryWrapper.eq("order_id",order.getOrderId());
            }
            // 实付金额。精确到2位小数;单位:元。如:200.07，表示:200元7分
            if(!StringUtils.isEmpty(order.getPayment())){
                 queryWrapper.eq("payment",order.getPayment());
            }
            // 支付类型，1、在线支付，2、货到付款
            if(!StringUtils.isEmpty(order.getPaymentType())){
                 queryWrapper.eq("payment_type",order.getPaymentType());
            }
            // 邮费。精确到2位小数;单位:元。如:200.07，表示:200元7分
            if(!StringUtils.isEmpty(order.getPostFee())){
                 queryWrapper.eq("post_fee",order.getPostFee());
            }
            // 状态：1、未付款，2、已付款，3、未发货，4、已发货，5、交易成功，6、交易关闭,7、待评价
            if(!StringUtils.isEmpty(order.getStatus())){
                 queryWrapper.eq("status",order.getStatus());
            }
            // 订单创建时间
            if(!StringUtils.isEmpty(order.getCreateTime())){
                 queryWrapper.eq("create_time",order.getCreateTime());
            }
            // 订单更新时间
            if(!StringUtils.isEmpty(order.getUpdateTime())){
                 queryWrapper.eq("update_time",order.getUpdateTime());
            }
            // 付款时间
            if(!StringUtils.isEmpty(order.getPaymentTime())){
                 queryWrapper.eq("payment_time",order.getPaymentTime());
            }
            // 发货时间
            if(!StringUtils.isEmpty(order.getConsignTime())){
                 queryWrapper.eq("consign_time",order.getConsignTime());
            }
            // 交易完成时间
            if(!StringUtils.isEmpty(order.getEndTime())){
                 queryWrapper.eq("end_time",order.getEndTime());
            }
            // 交易关闭时间
            if(!StringUtils.isEmpty(order.getCloseTime())){
                 queryWrapper.eq("close_time",order.getCloseTime());
            }
            // 物流名称
            if(!StringUtils.isEmpty(order.getShippingName())){
                 queryWrapper.eq("shipping_name",order.getShippingName());
            }
            // 物流单号
            if(!StringUtils.isEmpty(order.getShippingCode())){
                 queryWrapper.eq("shipping_code",order.getShippingCode());
            }
            // 用户id
            if(!StringUtils.isEmpty(order.getUserId())){
                 queryWrapper.eq("user_id",order.getUserId());
            }
            // 买家留言
            if(!StringUtils.isEmpty(order.getBuyerMessage())){
                 queryWrapper.eq("buyer_message",order.getBuyerMessage());
            }
            // 买家昵称
            if(!StringUtils.isEmpty(order.getBuyerNick())){
                 queryWrapper.eq("buyer_nick",order.getBuyerNick());
            }
            // 买家是否已经评价
            if(!StringUtils.isEmpty(order.getBuyerRate())){
                 queryWrapper.eq("buyer_rate",order.getBuyerRate());
            }
            // 收货人地区名称(省，市，县)街道
            if(!StringUtils.isEmpty(order.getReceiverAreaName())){
                 queryWrapper.eq("receiver_area_name",order.getReceiverAreaName());
            }
            // 收货人手机
            if(!StringUtils.isEmpty(order.getReceiverMobile())){
                 queryWrapper.eq("receiver_mobile",order.getReceiverMobile());
            }
            // 收货人邮编
            if(!StringUtils.isEmpty(order.getReceiverZipCode())){
                 queryWrapper.eq("receiver_zip_code",order.getReceiverZipCode());
            }
            // 收货人
            if(!StringUtils.isEmpty(order.getReceiver())){
                 queryWrapper.eq("receiver",order.getReceiver());
            }
            // 过期时间，定期清理
            if(!StringUtils.isEmpty(order.getExpire())){
                 queryWrapper.eq("expire",order.getExpire());
            }
            // 发票类型(普通发票，电子发票，增值税发票)
            if(!StringUtils.isEmpty(order.getInvoiceType())){
                 queryWrapper.eq("invoice_type",order.getInvoiceType());
            }
            // 订单来源：1:app端，2：pc端，3：M端，4：微信端，5：手机qq端
            if(!StringUtils.isEmpty(order.getSourceType())){
                 queryWrapper.eq("source_type",order.getSourceType());
            }
            // 商家ID
            if(!StringUtils.isEmpty(order.getSellerId())){
                 queryWrapper.eq("seller_id",order.getSellerId());
            }
        }
        return queryWrapper;
    }



    /**
     * 删除
     * @param id
     */
    @Override
    public void delete(Long id){
        this.removeById(id);
    }

    /**
     * 修改Order
     * @param order
     */
    @Override
    public void update(Order order){
        this.updateById(order);
    }


    /**
     * 根据ID查询Order
     * @param id
     * @return
     */
    @Override
    public Order findById(Long id){
        return  this.getById(id);
    }

    /**
     * 查询Order全部数据
     * @return
     */
    @Override
    public List<Order> findAll() {
        return this.list(new QueryWrapper<Order>());
    }

}
